/**
 * 添加掉血 溅射伤害
 * @param {*} fight_data 
 * @param {*} src_unit 
 * @param {*} target_unit 
 * @param {*} damage 
 * @param {*} skill_name 
 */
export function remove_hp_js_and_play(fight_data, src_unit, target_unit, damage = 1, skill_name) {
    console.debug("添加掉血 溅射伤害, remove_hp_js_and_play")
    let die = computing_remove_hp(fight_data, src_unit, target_unit, damage, skill_name);
    // 添加回血流程
    if (fight_data["战斗流程"].length === 0) {
        fight_data["战斗流程"].push({});
    }
    if (fight_data["战斗流程"][fight_data["战斗流程"].length - 1]["溅射"] === undefined) {
        fight_data["战斗流程"][fight_data["战斗流程"].length - 1]["溅射"] = [];
    }
    fight_data["战斗流程"][fight_data["战斗流程"].length - 1]["溅射"].push({
        "攻击方": src_unit["编号"],
        "编号": target_unit["编号"],
        "伤害": damage,
        "死亡": die,
    });
}
/**
 * 单位掉血计算
 * @param {*} fight_data 
 * @param {*} src_unit 
 * @param {*} target_unit 
 * @param {*} hp 
 * @param {*} skill_name 
 * @param {*} firent_damage 
 * @returns 
 */
export function computing_remove_hp(fight_data, src_unit, target_unit, hp, skill_name, firent_damage = false) {
    console.debug(`单位掉血计算 src_unit：${src_unit["编号"]} ${src_unit["气血"]}  target_unit：${target_unit["编号"]} hp: ${hp} 技能: ${skill_name} 目标气血：${target_unit["气血"]}`);

    if (Number.isNaN(hp)) {
        hp = 1;
    }

    if (!firent_damage && target_unit["护盾"] > 0) {
        if (target_unit["护盾"] >= hp) {
            target_unit["护盾"] = target_unit["护盾"] - hp;
            hp = 0;
        } else {
            hp = hp - target_unit["护盾"];
            target_unit["护盾"] = 0
        }
    }

    target_unit["气血"] -= hp;

    // 角色掉血百分比添加愤怒值
    if (target_unit["类型"] === "角色") {
        let bfb = Math.floor(hp / target_unit["最大气血"] * 100);
        let num = 1;
        if (bfb >= 3 && bfb <= 10) {
            num = 3;
        } else if (bfb > 10 && bfb <= 20) {
            num = 10;
        } else if (bfb > 20 && bfb <= 30) {
            num = 15;
        } else if (bfb > 30 && bfb <= 50) {
            num = 25;
        } else if (bfb > 50 && bfb <= 80) {
            num = 40;
        } else if (bfb > 80 && bfb <= 100) {
            num = 55;
        }
        // 添加愤怒
        target_unit["扣血回复愤怒"] = num;
        G.FightUnitUtils.add_fen_nu(target_unit, num);
    }

    // 技能扣血触发
    let skill_data = G.SkillData.default[skill_name];
    if (skill_data && skill_data["扣血触发"]) {
        skill_data["扣血触发"](fight_data, src_unit, target_unit, hp);
    }

    // 奇经八脉扣血触发
    if (src_unit["奇经八脉"] && src_unit["门派"] && src_unit["门派"] !== "无门派") {
        let sects_jing_mai_data = G.JingMaiData.default[src_unit["门派"]];
        if (sects_jing_mai_data) {
            // 已点经脉
            for (const key in src_unit["奇经八脉"]) {
                if (src_unit["奇经八脉"][key] === 1 && sects_jing_mai_data[key] && sects_jing_mai_data[key]["扣血触发"]) {
                    sects_jing_mai_data[key]["扣血触发"](fight_data, src_unit, target_unit);
                }
            }
        }
    }

    // 扣血后死亡处理
    if (target_unit["气血"] <= 0) {

        target_unit["气血"] = 0;

        G.FightUtils.add_waiting_play_time(fight_data, 2, "死亡");
        if (target_unit["死亡击飞"]) {
            G.FightUtils.add_waiting_play_time(fight_data, 2, "死亡击飞");
        }

        // 技能击杀触发
        let skill_data = G.SkillData.default[skill_name];
        if (skill_data && skill_data["击杀触发"]) {
            console.debug(`击杀触发 技能 ${skill_name}`)
            skill_data["击杀触发"](fight_data, src_unit, target_unit);
        }

        // 法术状态击杀触发
        for (const key in src_unit["法术状态"]) {
            if (G.SkillData.default[key] && G.SkillData.default[key]["击杀触发"]) {
                console.debug(`击杀触发 法术状态 ${key}`)
                G.SkillData.default[key]["击杀触发"](fight_data, src_unit, target_unit);
            }
        }

        // 法术状态死亡触发
        for (const key in target_unit["法术状态"]) {
            if (G.SkillData.default[key] && G.SkillData.default[key]["死亡触发"]) {
                console.debug(`死亡触发 法术状态 ${key}`)
                G.SkillData.default[key]["死亡触发"](fight_data, src_unit, target_unit);
            }
        }

        // 奇经八脉击杀触发
        if (src_unit["奇经八脉"] && src_unit["门派"] !== "无门派") {
            let sects_jing_mai_data = G.JingMaiData.default[src_unit["门派"]];
            //门派统一处理
            if (sects_jing_mai_data["击杀触发"]) {
                console.debug(`击杀触发 门派 ${src_unit["门派"]}`)
                sects_jing_mai_data["击杀触发"](fight_data, src_unit, target_unit);
            }
            // 已点经脉
            for (const key in src_unit["奇经八脉"]) {
                if (src_unit["奇经八脉"][key] === 1 && sects_jing_mai_data[key] && sects_jing_mai_data[key]["击杀触发"]) {
                    console.debug(`击杀触发 奇经八脉 ${key}`)
                    sects_jing_mai_data[key]["击杀触发"](fight_data, src_unit, target_unit);
                }
            }
        }

        // 奇经八脉死亡触发
        if (target_unit["奇经八脉"] && target_unit["门派"] !== "无门派") {
            let sects_jing_mai_data = G.JingMaiData.default[target_unit["门派"]];
            //门派统一处理
            if (sects_jing_mai_data["死亡触发"]) {
                console.debug(`死亡触发 门派 ${src_unit["门派"]}`)
                sects_jing_mai_data["死亡触发"](fight_data, src_unit, target_unit);
            }
            // 已点经脉
            for (const key in target_unit["奇经八脉"]) {
                if (target_unit["奇经八脉"][key] === 1 && sects_jing_mai_data[key] && sects_jing_mai_data[key]["死亡触发"]) {
                    console.debug(`死亡触发 奇经八脉 ${key}`)
                    sects_jing_mai_data[key]["死亡触发"](fight_data, src_unit, target_unit);
                }
            }
        }

        // 神器死亡触发
        if (target_unit["神器"] && target_unit["神器"]["佩戴"]) {
            let skill_data = G.SkillData.default[target_unit["神器"]["名称"]];
            if (skill_data["死亡触发"]) {
                console.debug(`死亡触发 神器 ${target_unit["神器"]["名称"]}`)
                skill_data["死亡触发"](fight_data, src_unit, target_unit);
            }
        }

        // 法宝击杀触发
        if (src_unit["法宝佩戴"]) {
            for (let index = 0; index < src_unit["法宝佩戴"].length; index++) {
                let fb = src_unit["法宝佩戴"][index];
                if (_FaBaoData.has(fb["名称"]) && _FaBaoData.get(fb["名称"])["击杀触发"]) {
                    console.debug(`击杀触发 法宝 ${fb["名称"]}`)
                    _FaBaoData.get(fb["名称"])["击杀触发"](fight_data, src_unit, target_unit);
                }
            }
        }

        // 法宝死亡触发
        if (target_unit["法宝佩戴"]) {
            for (let index = 0; index < target_unit["法宝佩戴"].length; index++) {
                let fb = target_unit["法宝佩戴"][index];
                if (_FaBaoData.has(fb["名称"]) && _FaBaoData.get(fb["名称"])["死亡触发"]) {
                    console.debug(`死亡触发 法宝 ${fb["名称"]}`)
                    _FaBaoData.get(fb["名称"])["死亡触发"](fight_data, src_unit, target_unit);
                }
            }
        }

        // TODO 召唤兽特性 概率添加自恋发言
        if (src_unit["自恋"]) {
            if (G.RandomUtils.chance(src_unit["自恋"])) {
                G.FightUtils.add_zilian_chat(fight_data, src_unit);
                src_unit["自恋"] = undefined;
            }
        }
        // TODO 召唤兽特性 召唤兽复仇
        if (target_unit["参战宝宝"]) {
            let target_pet_unit = G.FightUnitUtils.get_fight_unit_pet(fight_data, target_unit);
            if (target_pet_unit["复仇"] && target_pet_unit["复仇"][2] < 3 && G.RandomUtils.chance(target_pet_unit["复仇"][0])) {
                target_pet_unit["复仇"][3] += 1;
                fight_data["附加流程"] = { "编号": target_pet_unit["编号"], "方式": "物理攻击", "目标": src_unit["编号"] };
            }
        }

        // 无间地狱 所有阵亡的单位会被附加2回合的“死亡禁锢”，持续3回合
        if (fight_data["全局状态"]["无间地狱"]) {
            G.FightStatusUtils.add_unit_status(fight_data, src_unit, target_unit, "死亡禁锢", target_unit["等级"], 3);
        }

        // 特定情况会保留愤怒,如果保留愤怒则不清零
        if (!target_unit["保留愤怒"]) {
            target_unit["愤怒"] = 0;
            target_unit["保留愤怒"] = undefined;
        }

        if (target_unit["类型"] === "角色" || (target_unit["类型"] === "怪物" && !target_unit["死亡击飞"])) {
            // 不会彻底死亡 无法继续行动
            target_unit["死亡"] = false;
            return 2;
        }

        // 不可复活
        if (src_unit["特殊状态"]["驱鬼"] && target_unit["鬼魂类"]) {
            // TODO 风卷残云 符石特性  击倒鬼魂目标时有xxx%几率将其打飞出场 src_unit["风卷残云"] && G.RandomUtils.chance(src_unit["风卷残云"]))) {
            // "驱鬼" 如果将鬼魂类怪物打死，对方将飞出场外而不能复活
            // "风卷残云" 如果将鬼魂类怪物打死，对方将飞出场外而不能复活
            target_unit["死亡击飞"] = true;
            target_unit["死亡"] = true;
            return 1;
        }

        // 鬼魂术复活
        if (target_unit["特殊状态"]["鬼魂术"]) {
            // 死亡xx回合后自动复活，不受异常状态影响
            G.FightStatusUtils.add_unit_status(fight_data, target_unit, target_unit, "复活", 11);
            target_unit["法术状态"]["复活"] = { "回合": target_unit["特殊状态"]["鬼魂术"] };
            target_unit["死亡"] = false;
            return 2;
        }
        target_unit["死亡"] = true;
        return 1;
    }
    return undefined;
}


/**
 * 扣血，但不播放击退动画
 * @param {*} fight_data 
 * @param {*} src_unit 
 * @param {*} target_unit 
 * @param {*} damage 
 * @param {*} skill_name 
 */
export function remove_hp_and_no_play(fight_data, src_unit, target_unit, skill_name, damage = 1) {
    console.debug(`扣血，但不播放击退动画 remove_hp_and_no_play`)
    if (damage < 1) {
        damage = 1;
    }
    //扣血
    let die = computing_remove_hp(fight_data, src_unit, target_unit, skill_name, damage);
    // 添加无动作掉血流程
    if (fight_data["战斗流程"].length === 0) {
        fight_data["战斗流程"].push({});
    }
    if (fight_data["战斗流程"][fight_data["战斗流程"].length - 1]["无动作掉血"] === undefined) {
        fight_data["战斗流程"][fight_data["战斗流程"].length - 1]["无动作掉血"] = [];
    }
    fight_data["战斗流程"][fight_data["战斗流程"].length - 1]["无动作掉血"].push({
        "编号": target_unit["编号"],
        "攻击方": src_unit["编号"],
        "伤害": damage,
        "死亡": die,
    });
}

/**
 * 回复气血 并播放动画
 * @param {*} fight_unit 
 * @param {*} hp 
 * @returns 
 */
export function add_target_hp_and_play(fight_data, fight_unit, hp = 1) {
    console.debug(`回复气血 并播放动画 编号：${fight_unit["编号"]} 气血：${fight_unit["气血"]}`)
    if (fight_unit["气血"] > fight_unit["最大气血"]) {
        return;
    }
    if (hp < 1) {
        hp = 1;
    }
    hp = Math.floor(hp + fight_unit["气血回复效果"]);

    // 回血
    G.FightUnitUtils.add_unit_hp(fight_unit, hp)

    // 添加回血流程
    if (fight_data["战斗流程"].length === 0) {
        fight_data["战斗流程"].push({});
    }
    if (fight_data["战斗流程"][fight_data["战斗流程"].length - 1]["回复气血"] === undefined) {
        fight_data["战斗流程"][fight_data["战斗流程"].length - 1]["回复气血"] = [];
    }

    fight_data["战斗流程"][fight_data["战斗流程"].length - 1]["回复气血"].push({
        "编号": fight_unit["编号"],
        "气血": hp,
    });
    fight_data["战斗流程"][fight_data["战斗流程"].length - 1]["技能提示"] = { "内容": "回血", "编号": fight_unit["编号"] };
    G.FightUtils.add_waiting_play_time(fight_data, 1, "添加气血动画");
}

/**
 * 法术状态触发持续回血 同步气血
 * @param {*} src_unit 
 * @param {*} target_unit 
 * @param {*} hp 
 * @param {*} skill_name 
 * @returns 
 */
export function add_target_hp_by_ap_status(fight_data, src_unit, target_unit, hp, skill_name) {
    console.debug(`法术状态触发持续回血开始 src_unit ${src_unit["编号"]} ${src_unit["气血"]} target_unit ${target_unit["编号"]} ${target_unit["气血"]} hp ${hp} skill_name ${skill_name}`)

    if (target_unit["气血"] > target_unit["最大气血"]) {
        return;
    }

    // 法术状态持续回血触发
    for (const key in target_unit["法术状态"]) {
        if (G.SkillData.default[key] && G.SkillData.default[key]["持续回血触发"]) {
            hp = G.SkillData.default[key]["持续回血触发"](fight_data, src_unit, target_unit, hp);
            if (hp === false) {
                return;
            }
        }
    }

    // 技能持续回血算法
    let skill_data = G.SkillData.default[skill_name];
    if (skill_data["持续回血"]) {
        hp = skill_data["持续回血"](fight_data, src_unit, target_unit, hp);
    }

    // 回血
    G.FightUnitUtils.add_unit_hp(target_unit, hp);

    // 添加回血流程
    if (fight_data["战斗流程"].length === 0) {
        fight_data["战斗流程"].push({});
    }
    if (fight_data["战斗流程"][fight_data["战斗流程"].length - 1]["同步气血"] === undefined) {
        fight_data["战斗流程"][fight_data["战斗流程"].length - 1]["同步气血"] = [];
    }
    fight_data["战斗流程"][fight_data["战斗流程"].length - 1]["同步气血"].push({
        "编号": target_unit["编号"],
        "气血": target_unit["气血"],
        "气血上限": target_unit["气血上限"],
    });
    console.debug(`法术状态触发持续回血结束 发起方 ${src_unit["编号"]} ${src_unit["气血"]} 目标 ${target_unit["编号"]} ${target_unit["气血"]} 血量 ${hp} 技能 ${skill_name}`)
}

/**
 * 行动前状态处理
 * @param {*} fight_data 
 * @param {*} src_unit 
 * @param {*} skill_name 
 */
function execute_befor_computing(fight_data, src_unit, skill_name) {
    console.debug(`行动前状态处理 => 编号: ${src_unit["编号"]} 类型: ${src_unit["类型"]} 气血: ${src_unit["气血"]}`);
    // 如果当前单位可行动则处理参战单位的各种法术状态
    if (G.FightUnitUtils.get_target_unit_status(src_unit, src_unit, 2) && !G.FightUtils.is_complete(fight_data)) {

        // 法术状态行动前触发(包含法宝灵宝的状态技能)
        for (const key in src_unit["法术状态"]) {
            console.debug(`行动前触发 ===> [${src_unit["编号"]}] 法术状态 ${key}`);
            let skill_data = G.SkillData.default[key];
            if (skill_data && skill_data["行动前触发"]) {
                skill_data["行动前触发"](fight_data, src_unit);
            }
        }

        // 奇经八脉行动前触发
        if (src_unit["奇经八脉"] && src_unit["门派"] !== "无门派") {
            let sects_jing_mai_data = G.JingMaiData.default[src_unit["门派"]];
            //门派统一处理
            if (sects_jing_mai_data["行动前触发"]) {
                console.debug(`行动前触发 ===> 门派 ${src_unit["门派"]}`);
                sects_jing_mai_data["行动前触发"](fight_data, src_unit);
            }
            // 已点经脉
            for (const key in src_unit["奇经八脉"]) {
                if (src_unit["奇经八脉"][key] === 1 && sects_jing_mai_data[key] && sects_jing_mai_data[key]["行动前触发"]) {
                    console.debug(`行动前触发 ===> 奇经八脉 ${key}`);
                    sects_jing_mai_data[key]["行动前触发"](fight_data, src_unit);
                }
            }
        }

        // TODO 召唤兽特性
        if (src_unit["再生"]) {
            let hp = src_unit["再生"];
            add_target_hp_by_ap_status(fight_data, src_unit, src_unit, hp);
        }

        // TODO 召唤兽特性
        if (src_unit["超级再生"]) {
            let hp = src_unit["等级"];
            if (G.RandomUtils.chance(10)) {
                hp = src_unit["等级"] * 12;
            }
            add_target_hp_and_play(src_unit, hp);
        }
        // TODO 召唤兽特性
        if (src_unit["冥思"]) {
            let mp = 1;
            if (src_unit["内丹属性"]["深思"]) {
                mp += src_unit["内丹属性"]["深思"];
            }
            G.FightUnitUtils.add_unit_mp(src_unit, Math.floor(src_unit["深思"] * mp));
        }
        // TDOO 召唤兽特性
        if (src_unit["汗血的"]) {
            let hp = Math.floor(src_unit["气血"] * 0.2);
            remove_hp_and_no_play(fight_data, src_unit, src_unit, skill_name, hp);
        }
        // TDOO 召唤兽特性
        if (src_unit["疯癫的"]) {
            src_unit["指令"]["类型"] = "攻击"
            src_unit["指令"]["攻击队友"] = true;
            if (G.RandomUtils.chance(50)) {
                let target = G.FightUtils.get_enemy_team_single_survive_unit(fight_data, src_unit);
                if (target !== undefined) {
                    src_unit["指令"]["目标"] = target["编号"];
                } else {
                    src_unit["指令"]["目标"] = undefined;
                    src_unit["指令"]["类型"] = "防御";
                }
            } else {
                let target = G.FightUtils.get_enemy_team_single_survive_unit(fight_data, src_unit);
                src_unit["指令"]["目标"] = target !== undefined ? target["编号"] : undefined;
            }
        }

    }
    // 七宝玲珑塔全局状态处理
    if (fight_data["全局状态"]["七宝玲珑塔"]) {
        let global_status = fight_data["全局状态"]["七宝玲珑塔"];
        let team_id = src_unit["队伍"];
        if (global_status[team_id] && global_status[team_id]["回合"] !== fight_data["回合"]) {
            let status_names = G.FightStatusUtils.relieve_status(fight_data, src_unit, G.Skill.fb_feng_yin_status_ap, 1);
            if (status_names.length > 0 && G.RandomUtils.chance(global_status[team_id]["境界"] * 2 + 10)) {
                // 在取消一次?
                G.FightStatusUtils.relieve_status(fight_data, src_unit, G.Skill.fb_feng_yin_status_ap);
                global_status[team_id]["回合"] = fight_data["回合"];
            }
        }
    }
    console.debug(`行动前状态处理结束 => 编号: ${src_unit["编号"]} 类型: ${src_unit["类型"]} 气血: ${src_unit["气血"]}`);
}

/**
 * 战斗流程计算
 * @param {*} src_unit 发起单位
 */
export function computing_process_data(fight_data, src_unit) {

    // 目标战斗单位
    let target_unit = G.FightUtils.get_fight_unit_by_number(fight_data, src_unit["指令"]["目标"]);

    console.debug(`战斗流程计算 => 编号: ${src_unit["编号"]} 类型: ${src_unit["类型"]} 目标编号 : ${target_unit ? target_unit["编号"] : "无"} 指令类型: ${src_unit["指令"]["类型"]} 单位是否存在: ${target_unit !== undefined}`);

    let skill_name = src_unit["指令"]["参数"];

    // 行动前状态处理
    execute_befor_computing(fight_data, src_unit, skill_name);

    fight_data["复活后继续"] = {};
    fight_data["超级神迹复活"] = {};

    // 如果正在执行命令的单位已死亡,则放入复活继续列表内
    if (src_unit["气血"] < 0 && fight_data["复活后继续"][src_unit["编号"]] === undefined) {
        fight_data["复活后继续"][src_unit["编号"]] = 1;
    }

    // 宠物超级神迹
    if (src_unit["气血"] < 0 && src_unit["超级神迹"]) {
        let master_unit = G.FightUtils.get_fight_unit_by_number(fight_data, Number(src_unit["编号"]) - 1);
        if (master_unit && master_unit["气血"] <= 0 && !G.FightUnitUtils.check_not_rebirth(master_unit)) {
            fight_data["超级神迹复活"][master_unit["编号"]] = src_unit["编号"];
        }
    }

    if (G.FightUnitUtils.get_target_unit_status(src_unit, src_unit, 2) && G.FightUtils.is_complete(fight_data) === undefined) {
        console.debug(`开始执行编号[${src_unit["编号"]}]的战斗指令，：${JSON.stringify(src_unit["指令"])}`)
        if (src_unit["指令"]["类型"] === "攻击") {
            if (G.FightUnitUtils.get_unit_attack_status(src_unit)) {
                if (src_unit["指令"]["附加"] === "友伤") {
                    if (target_unit && target_unit["队伍"] === src_unit["队伍"] && G.FightUnitUtils.get_target_unit_status(src_unit, target_unit, 2)) {
                        console.debug(`攻击队友`);
                        G.FightNormalAttackUtils.computing_normal_attack(fight_data, src_unit, 1, true);
                    }
                } else {
                    console.debug(`攻击敌方队伍`);
                    if (!G.FightSkillUtils.default["连击算法"](fight_data, src_unit, target_unit, "高级连击")
                        && !G.FightSkillUtils.default["连击算法"](fight_data, src_unit, target_unit, "超级连击")) {
                        G.FightSkillUtils.default["普通攻击"](fight_data, src_unit);
                    }
                }
            } else {
                console.debug(`单位 ${src_unit["编号"]} 当前不可使用普通攻击，跳过计算`)
                fight_data["战斗流程"].push({ "流程": 6, "战斗提示": { "内容": "行动失败(禁用普攻)", "编号": src_unit["编号"] } });
            }
        } else if (src_unit["指令"]["类型"] === "法术") {
            // 特性技能攻击判断一下是否可用
            if (ex_skill[skill_name]) {
                console.debug(`特性技能攻击`)
                if (G.FightUnitUtils.get_unit_ap_ex_kill_status(src_unit)) {
                    computing_skill(fight_data, src_unit, target_unit, skill_name);
                    if (src_unit["法术状态"]["愈勇"]) {
                        G.FightStatusUtils.canel_unit_status(fight_data, "愈勇", src_unit);
                    }
                }
            }
            else {
                console.debug(`使用主动技能`)
                // 其他主动技能
                if (G.FightUnitUtils.get_unit_ap_kill_status(src_unit)) {
                    // 如果技能还在CD中则直接停止
                    if (!G.FightUnitUtils.get_unit_ap_skill_cd(src_unit, skill_name)) {
                        fight_data["战斗流程"].push({ "流程": 6, "战斗提示": { "内容": "行动失败(技能冷却)", "编号": src_unit["编号"] } });
                        return;
                    }
                    // 血量对疯狂鹰击的影响
                    if (skill_name === "疯狂鹰击" && src_unit["气血"] < src_unit["最大气血"] * 0.9) {
                        src_unit["指令"]["参数"] = "鹰击";
                        skill_name = "鹰击";
                    }
                    // 根据技能类型执行算法
                    computing_skill(fight_data, src_unit, target_unit, skill_name);
                    let skill_data = G.SkillData.default[skill_name];
                    if (skill_data && skill_data["如意神通"] && G.FightUnitUtils.check_unit_shen_qi_skill(src_unit, "开辟")) {
                        G.FightStatusUtils.add_unit_status(fight_data, src_unit, src_unit, "开辟", 11);
                    }
                } else {
                    console.debug(`单位 ${src_unit["编号"]} 当前不可使用主动技能，跳过计算`)
                    fight_data["战斗流程"].push({ "流程": 6, "战斗提示": { "内容": "行动失败(禁用技能)", "编号": src_unit["编号"] } });
                }
            }
        } else if (src_unit["指令"]["类型"] === "道具" && src_unit["法术状态"]["煞气诀"] === undefined) {
            console.debug(`使用道具`)
            G.FightItemUtils.computing_item_process_data(fight_data, src_unit, target_unit, src_unit["指令"]["参数"] - 1)


        } else if (src_unit["指令"]["类型"] === "捕捉" && src_unit["类型"] === "角色") {
            computing_capture_process_data(fight_data, src_unit, target_unit);
        } else if (src_unit["指令"]["类型"] === "召唤" && src_unit["类型"] === "角色" && src_unit["法术状态"]["月下霓裳"] === undefined) {
            console.debug(`召唤`)
            // let bb = 战斗数据:取玩家召唤兽(编号)
            // let gd = 0
            // if （战斗数据.单挑模式){
            // 	gd = 战斗数据:单挑召唤计算(战斗数据.执行对象[n],src_unit["指令"].位置)
            // else
            // 	gd = 战斗数据:召唤计算(战斗数据.执行对象[n])
            // end
            // if bb===0 && gd ){
            // 	if G.FightUnitUtils.check_fight_unit_jingmai(src_unit, "狮驼岭", "肝胆") ){
            // 		G.FightStatusUtils.add_unit_status(fight_data, src_unit, src_unit, "肝胆", 11);
            // 	}else if( G.FightUnitUtils.check_fight_unit_jingmai(src_unit, "狮驼岭", "长啸") ){
            // 		G.FightStatusUtils.add_unit_status(fight_data, src_unit, src_unit, "狂怒", 11,nil,3);
            // 	end
            // end
        } else if (src_unit["指令"]["类型"] === "逃跑") {
            computing_run_away(fight_data, src_unit);
        } else if (src_unit["指令"]["类型"] === "披坚执锐") {
            console.debug(`主动使用披坚执锐`)
            G.SkillData.default["披坚执锐"]["主动触发"](fight_data, src_unit);
        }

        // 同步单位的属性
        let last_index = fight_data["战斗流程"].length - 1;
        if (fight_data["战斗流程"][last_index]["攻击方"] === src_unit["编号"]) {
            fight_data["战斗流程"][last_index]["魔法"] = src_unit["魔法"];
            fight_data["战斗流程"][last_index]["最大魔法"] = src_unit["最大魔法"];
            fight_data["战斗流程"][last_index]["气血"] = src_unit["气血"];
            fight_data["战斗流程"][last_index]["最大气血"] = src_unit["最大气血"];
            fight_data["战斗流程"][last_index]["护盾"] = src_unit["护盾"];
            fight_data["战斗流程"][last_index]["愤怒"] = src_unit["愤怒"];
            fight_data["战斗流程"][last_index]["战意"] = src_unit["战意"];
            fight_data["战斗流程"][last_index]["超级战意"] = src_unit["超级战意"];
            fight_data["战斗流程"][last_index]["五行珠"] = src_unit["五行珠"];
            if (src_unit["门派"] !== "九黎城") {
                fight_data["战斗流程"][last_index]["人参果"] = src_unit["人参果"];
                fight_data["战斗流程"][last_index]["骤雨"] = src_unit["骤雨"];
            }
        }

        // TODO 附加流程计算 复仇反击
        if (fight_data["附加流程"] && fight_data["附加流程"]["编号"] && fight_data["附加流程"]["方式"] === "物理攻击") {
            console.debug(`战斗流程计算  附加流程 => 编号: ${fight_data["附加流程"]["编号"]} 目标 : ${fight_data["附加流程"]["目标"]} `);
            let src_number = fight_data["附加流程"]["编号"];
            let src = G.FightUtils.get_fight_unit_by_number(fight_data, src_number);
            let target_number = fight_data["附加流程"]["目标"];
            let target = G.FightUtils.get_fight_unit_by_number(fight_data, target_number);
            src["指令"]["目标"] = target_number;
            G.FightNormalAttackUtils.computing_normal_attack(fight_data, src, target, 1);
            fight_data["战斗流程"][fight_data["战斗流程"].length - 1]["战斗提示"] = { "内容": "复仇", "编号": fight_data["附加流程"]["目标"] };
            fight_data["附加流程"] = {};
        }

        console.debug(`战斗流程计算结束 => 编号: ${src_unit["编号"]} 类型: ${src_unit["类型"]} 目标编号 : ${target_unit ? target_unit["编号"] : "无"} 指令类型: ${src_unit["指令"]["类型"]} `);
    }
}


/**
 * 计算技能
 * @param {*} fight_data 
 * @param {*} src_unit 
 * @param {*} target_unit 
 * @param {*} skill_name 
 */
export function computing_skill(fight_data, src_unit, target_unit, skill_name, skill_level) {
    console.debug(`计算技能 => 编号: ${src_unit["编号"]} 类型:${src_unit["类型"]} 技能：${skill_name}`);
    // 技能信息
    let skill_data = G.SkillData.default[skill_name];
    if (skill_data) {
        if (skill_data["技能类型"] === "增益") {
            // 增益技能计算
            if (target_unit === undefined) {
                console.debug(`计算技能 => 增益技能的目标不存在，跳过`);
                fight_data["战斗流程"].push({ "流程": 6, "战斗提示": { "内容": "行动失败(无目标)", "编号": src_unit["编号"] } });
            } else {
                G.FightBuffSkillUtils.computing_buff_skill(fight_data, src_unit, target_unit, skill_name, skill_level);
            }
        } else if (skill_data["技能类型"] === "减益") {
            // 减益技能计算
            G.FightBuffSkillUtils.computing_debuff_skill(fight_data, src_unit, target_unit, skill_name, skill_level);
        } else if (skill_data["技能类型"] === "恢复") {
            // 恢复技能计算
            G.FightRegenSkillUtils.computing_regen_skill(fight_data, src_unit, target_unit, skill_name);
        } else if (skill_data["技能类型"] === "群封") {
            //群体封印技能计算
            G.FightSealSkillUtils.computing_batch_seal_skill(fight_data, src_unit, target_unit, skill_name);
        } else if (skill_data["技能类型"] === "单封") {
            //单体封印技能计算
            console.debug("1111111111111111111111111111")
            G.FightSealSkillUtils.computing_single_seal_skill(fight_data, src_unit, target_unit, skill_name);
            console.debug("1111111111111111111111111111")
        } else if (skill_data["技能类型"] === "固伤") {
            // 固伤技能计算
            G.FightFinalSkillUtils.computing_final_skill(fight_data, src_unit, target_unit, skill_name, 1);
        } else if (skill_data["技能类型"] === "物理") {
            // 物攻技能计算
            let skill_level = G.FightUnitUtils.get_unit_skill_level(src_unit, skill_name);
            G.FightADSkillUtils.computing_ad_skill(fight_data, src_unit, skill_name, skill_level);
        } else if (skill_data["技能类型"] === "法术") {
            // 观照万象 使用所有使用主动技能
            if (skill_name === "观照万象") {
                batch_exec_skill(fight_data, src_unit, target_unit);
            } else {
                //法术计算
                G.FightAPSkillUtils.computing_ap_skill(fight_data, src_unit, target_unit, skill_name);
            }
        } else if (skill_data["技能类型"] === "逃跑") {
            computing_run_away(fight_data, src_unit);
        } else if (skill_data["技能类型"] === "特殊") {
            if (skill_data["特殊算法"]) {
                let skill_level = G.FightUnitUtils.get_unit_skill_level(src_unit, skill_name);
                skill_data["特殊算法"](fight_data, src_unit, target_unit, skill_level);
            } else {
                console.warn(`特殊技能 [${skill_name}] 未配置特殊算法 `);
            }
        } else {
            console.warn(`[${skill_name}] 未配置技能类型, 本次跳过执行, 需检查技能配置 `);
        }
    } else {
        console.warn(`技能 [${skill_name}] 未配置`);
    }
}


/**
 * 批量执行技能
 * @param {*} fight_data 
 * @param {*} src_unit 
 * @param {*} target_unit 
 */
function batch_exec_skill(fight_data, src_unit, target_unit) {
    let skill_type_list = ["物理", "法术", "固伤", "增益"];
    for (let index = 0; index < src_unit["主动技能"].length; index++) {
        let skill = src_unit["主动技能"][index];
        let tmp_skill_name = skill["名称"];
        let skill_data = G.SkillData.default[tmp_skill_name];
        if (index < 7 && tmp_skill_name !== "观照万象" && skill_data && skill_type_list.includes(skill_data["技能类型"])) {
            // 计算技能
            computing_skill(fight_data, src_unit, target_unit, tmp_skill_name)
        }
    }
}

/**
 * 取伤害结果 如果保护存在 不触发神佑效果
 * @param {*} fight_data 战斗数据
 * @param {*} src_unit 攻击单位
 * @param {*} target_unit 目标单位
 * @param {*} damage  伤害
 * @param {*} bj 暴击
 * @param {*} skill_name 技能名
 * @param {*} bh 是否被保护
 * @param {*} fy 防御
 * @param {*} skill_type 类型 1物理 2法术
 * @returns 
 */
export function get_damage_result(fight_data, src_unit, target_unit, damage, bj = false, skill_name, bh, fy, skill_type) {
    console.debug(`取伤害结果开始 => src_unit : ${src_unit["编号"]} target_unit :${target_unit["编号"]}  damage: ${damage} skill_name: ${skill_name}`);
    let tx = [];
    if (damage < 1) {
        damage = 1;
    }
    if (fy) {
        tx.push("防御");
    }
    // 最终返回的流程类型
    let type = 1

    // 取伤害结果

    // 攻击单位法术状态对伤害结果的影响
    for (const key in src_unit["法术状态"]) {
        if (G.SkillData.default[key] && G.SkillData.default[key]["攻击伤害结果"]) {
            console.debug(`攻击伤害结果 ===> 法术状态 ${key}`);
            let res = G.SkillData.default[key]["攻击伤害结果"](fight_data, src_unit, target_unit, damage);
            if (res) {
                return res;
            }
        }
    }

    // 被攻击单位法术状态对伤害结果的影响
    for (const key in target_unit["法术状态"]) {
        if (G.SkillData.default[key] && G.SkillData.default[key]["被攻击伤害结果"]) {
            console.debug(`被攻击伤害结果 ===> 法术状态 ${key}`);
            let res = G.SkillData.default[key]["被攻击伤害结果"](fight_data, src_unit, target_unit, damage);
            if (res) {
                return res;
            }
        }
    }

    // 攻击单位奇经八脉对伤害结果的影响
    if (src_unit["奇经八脉"] && src_unit["门派"] !== "无门派") {
        let sects_jing_mai_data = G.JingMaiData.default[src_unit["门派"]];
        //门派统一处理
        if (sects_jing_mai_data["攻击伤害结果"]) {
            sects_jing_mai_data["攻击伤害结果"](fight_data, src_unit, target_unit, damage);
        }
        // 已点经脉
        for (const key in src_unit["奇经八脉"]) {
            if (src_unit["奇经八脉"][key] === 1 && sects_jing_mai_data[key] && sects_jing_mai_data[key]["攻击伤害结果"]) {
                sects_jing_mai_data[key]["攻击伤害结果"](fight_data, src_unit, target_unit, damage);
            }
        }
    }

    // 被攻击单位奇经八脉对伤害结果的影响
    if (target_unit["奇经八脉"] && target_unit["门派"] !== "无门派") {
        let sects_jing_mai_data = G.JingMaiData.default[target_unit["门派"]];
        //门派统一处理
        if (sects_jing_mai_data["被攻击伤害结果"]) {
            sects_jing_mai_data["被攻击伤害结果"](fight_data, src_unit, target_unit, damage);
        }
        // 已点经脉
        for (const key in target_unit["奇经八脉"]) {
            if (target_unit["奇经八脉"][key] === 1 && sects_jing_mai_data[key] && sects_jing_mai_data[key]["被攻击伤害结果"]) {
                sects_jing_mai_data[key]["被攻击伤害结果"](fight_data, src_unit, target_unit, damage);
            }
        }
    }

    //  攻击单位内丹属性对伤害结果的影响
    for (const key in src_unit["内丹属性"]) {
        let nei_dan_data = G.NeiDanData.default[key]
        if (nei_dan_data && nei_dan_data["攻击伤害结果"]) {
            console.debug(`攻击伤害结果 ===> 内丹属性 ${key}`);
            nei_dan_data["攻击伤害结果"](fight_data, src_unit, target_unit, damage);
        }
    }

    //  被攻击单位内丹属性对伤害结果的影响
    for (const key in target_unit["内丹属性"]) {
        let nei_dan_data = G.NeiDanData.default[key]
        if (nei_dan_data && nei_dan_data["被攻击伤害结果"]) {
            console.debug(`被攻击伤害结果 ===> 内丹属性 ${key}`);
            nei_dan_data["被攻击伤害结果"](fight_data, src_unit, target_unit, damage);
        }
    }


    // 神佑触发 TODO 特性
    if (!bh && src_unit["法术状态"]["灵断"] === undefined && damage >= target_unit["气血"] && target_unit["神佑"] && G.RandomUtils.chance(target_unit["神佑"])) {
        damage = target_unit["最大气血"]
        if (target_unit["神佑"] < 30) {
            damage = target_unit["最大气血"] * 0.6;
        }
        if (target_unit["认证码"]) {
            let master = G.FightUtils.get_fight_unit_by_number(fight_data, target_unit["主人编号"])
            let target_pet_data = G.FightUnitUtils.get_fight_unit_pet(fight_data, master);
            if (target_pet_data["技能"].includes("超级神柚复生")) {
                G.FightUnitUtils.add_hu_dun_for_lt_max_hp(fight_data, target_unit, target_unit["最大气血"]);
                target_unit["神佑复活"] = true;
            }
        }
        console.debug(`取伤害结果结束 => ${damage}`)
        return { "伤害": Math.floor(damage), "类型": 2, "特效": tx };
    }

    // 物法通用伤害 ----------

    //方寸山门派特色
    if (src_unit["门派"] === "方寸山") {
        if (target_unit["特殊状态"]["鬼魂术"]) {
            damage = damage * 2;
        } else if (target_unit["门派"] === "阴曹地府") {
            damage = damage * 1.1;
        }
    }

    // 驭兽 本方的所有召唤兽造成的伤害提高3%，
    if (src_unit["认证码"] && G.FightUtils.hash_fight_count_data(fight_data, src_unit, "经脉", "驭兽")) {
        damage = damage * 1.03;
    }

    // 驭兽 受到的伤害降低3%
    if (src_unit["认证码"] && G.FightUtils.hash_fight_count_data(fight_data, target_unit, "经脉", "驭兽")) {
        damage = damage * 0.97;
    }

    //  本方玩家单位造成的物理和法术伤害提高4%。
    if (src_unit["类型"] === "角色" && G.FightUtils.hash_fight_count_data(fight_data, src_unit, "经脉", "贯通")) {
        damage = damage * 1.04;
    }
    if (target_unit["认证码"]) {
        //  TODO 特性
        if (target_unit["巧劲"]) {
            damage += damage * target_unit["巧劲"][1];
        }
        //  TODO 特性
        if (target_unit["识药"]) {
            damage += damage * target_unit["识药"][1];
        }
        //  TODO 特性
        if (target_unit["御风"]) {
            damage += damage * target_unit["御风"][1];
        }
        //  TODO 统御属性
        if (target_unit["统御属性"] && target_unit["统御属性"]["偃旗息鼓"]) {
            damage = Math.floor(damage * (1 - target_unit["统御属性"]["偃旗息鼓"]));
        }
    }

    // TODO 写到这里
    if (target_unit["超级隐身"]) {
        damage = damage * 0.9;
    }

    if (target_unit && target_unit["超级招架"]) {
        target_unit["超级招架"] = undefined;
        damage = 11;
    }

    // 五行克制伤害加成
    if (src_unit["克敌五行"] && src_unit["五行"] && target_unit["五行"]) {
        if (src_unit["五行"] === G.FightUtils.get_wx_suppress(target_unit["五行"])) {
            damage = damage * 1.5;
        }
    }

    // 同门单位3人以上伤害减半
    if (G.FightUtils.get_friend_team_sects_count(fight_data, src_unit) >= 3) {
        damage = Math.floor(damage / 2);
    }

    // 物法通用伤害 ----------

    if (skill_type === 1) {
        //物理
        let res = get_ad_damage_result(fight_data, src_unit, target_unit, damage, bj, skill_name, type);
        damage = res[0];
        type = res[1];
        tx = res[2];
    } else if (skill_type === 2) {
        //法系
        let res = get_ap_damage_result(fight_data, src_unit, target_unit, damage, bj, skill_name, type);
        damage = res[0];
        type = res[1];
        tx = res[2];
    }

    if (damage < 1) { damage = 1; }
    let damage_result = { "伤害": Math.floor(damage), "类型": type, "特效": tx };
    console.debug(`取伤害结果结束 => ${JSON.stringify(damage_result)}`)
    return damage_result;
}

/**
 * 取物理伤害结果
 * @param {*} fight_data 
 * @param {*} src_unit 
 * @param {*} target_unit 
 * @param {*} damage 
 * @param {*} bj 
 * @param {*} skill_name 
 * @param {*} type 
 * @returns 
 */
function get_ad_damage_result(fight_data, src_unit, target_unit, damage, bj, skill_name, type) {
    let skill_data = G.SkillData.default[skill_name];
    let tx = [];
    if (skill_name && !skill_data["无特效"]) {
        tx.push(skill_name);
    }
    if (bj) {
        type = 3;
        tx.push("暴击");
    }

    if (G.FightUnitUtils.check_unit_fa_bao(fight_data, target_unit, "金甲仙衣")) {
        damage = damage * 0.55;
        tx.push("金甲仙衣");
    } else if (G.FightUnitUtils.check_unit_fa_bao(fight_data, target_unit, "蟠龙玉璧")) {
        damage = damage * 0.8;
        if (!tx.includes("金甲仙衣")) {
            tx.push("金甲仙衣");
        }
    }
    if (target_unit["内丹属性"]["腾挪劲"] && G.RandomUtils.chance(target_unit["内丹属性"]["腾挪劲"])) {
        damage = damage * 0.5;
        tx.push("腾挪劲");
    }

    // 攻击单位法术状态对物理伤害结果的影响
    for (const key in src_unit["法术状态"]) {
        if (G.SkillData.default[key] && G.SkillData.default[key]["攻击物伤结果"]) {
            let res = G.SkillData.default[key]["攻击物伤结果"](fight_data, src_unit, target_unit, damage);
            if (res) {
                return res;
            }
        }
    }

    // 被攻击单位法术状态对物理伤害结果的影响
    for (const key in target_unit["法术状态"]) {
        if (G.SkillData.default[key] && G.SkillData.default[key]["被攻击物伤结果"]) {
            let res = G.SkillData.default[key]["被攻击物伤结果"](fight_data, src_unit, target_unit, damage);
            if (res) {
                return res;
            }
        }
    }

    // 攻击单位奇经八脉对物理伤害结果的影响
    if (src_unit["奇经八脉"] && src_unit["门派"] !== "无门派") {
        let sects_jing_mai_data = G.JingMaiData.default[src_unit["门派"]];
        //门派统一处理
        if (sects_jing_mai_data["攻击物伤结果"]) {
            sects_jing_mai_data["攻击物伤结果"](fight_data, src_unit, target_unit, damage);
        }
        // 已点经脉
        for (const key in src_unit["奇经八脉"]) {
            if (src_unit["奇经八脉"][key] === 1 && sects_jing_mai_data[key] && sects_jing_mai_data[key]["攻击物伤结果"]) {
                sects_jing_mai_data[key]["攻击物伤结果"](fight_data, src_unit, target_unit, damage);
            }
        }
    }

    // 被攻击单位奇经八脉对物理伤害结果的影响
    if (target_unit["奇经八脉"] && target_unit["门派"] !== "无门派") {
        let sects_jing_mai_data = G.JingMaiData.default[target_unit["门派"]];
        //门派统一处理
        if (sects_jing_mai_data["被攻击物伤结果"]) {
            sects_jing_mai_data["被攻击物伤结果"](fight_data, src_unit, target_unit, damage);
        }
        // 已点经脉
        for (const key in target_unit["奇经八脉"]) {
            if (target_unit["奇经八脉"][key] === 1 && sects_jing_mai_data[key] && sects_jing_mai_data[key]["被攻击物伤结果"]) {
                sects_jing_mai_data[key]["被攻击物伤结果"](fight_data, src_unit, target_unit, damage);
            }
        }
    }

    //  攻击单位内丹属性对物理伤害结果的影响
    for (const key in src_unit["内丹属性"]) {
        let nei_dan_data = G.NeiDanData.default[key]
        if (nei_dan_data && nei_dan_data["攻击物伤结果"]) {
            console.debug(`攻击物伤结果 ===> 内丹属性 ${key}`);
            nei_dan_data["攻击物伤结果"](fight_data, src_unit, target_unit, damage);
        }
    }

    //  被攻击单位内丹属性对物理伤害结果的影响
    for (const key in target_unit["内丹属性"]) {
        let nei_dan_data = G.NeiDanData.default[key]
        if (nei_dan_data && nei_dan_data["被攻击物伤结果"]) {
            console.debug(`被攻击物伤结果 ===> 内丹属性 ${key}`);
            nei_dan_data["被攻击物伤结果"](fight_data, src_unit, target_unit, damage);
        }
    }

    // 技能的物理伤害结果算法
    if (skill_data && skill_data["物理伤害结果"]) {
        skill_data["物理伤害结果"](fight_data, src_unit, target_unit, damage);
    }

    if (src_unit["强力"] && target_unit["特殊状态"]["防御技能"]) {
        damage = damage * 0.8
    }

    if (fight_data["回合"] <= 2 && src_unit["修业"] && src_unit["修业"]["五"] === "爆裂" && !fight_data["PK战斗"]) {
        damage = damage * 1.3
    }
    if (src_unit["爆裂触发"] && !fight_data["PK战斗"]) {
        damage = damage * 1.3
        src_unit["爆裂触发"] = undefined
    }

    if (fight_data["回合"] <= 2 && src_unit["修业"] && src_unit["修业"]["五"] === "破伤" && !fight_data["PK战斗"]) {
        damage = damage * 0.5
    }

    if (src_unit["认证码"]) {
        if (src_unit["力破"] && target_unit["认证码"]) {
            if (!src_unit["法术状态"]["灵刃"]) {
                damage -= damage * src_unit["力破"][1];
            }
        }
        if (src_unit["超级合纵"] && src_unit["超级合纵"] > 0) {
            let hz = src_unit["超级合纵"];
            if (hz > 4) { hz = 4 };
            let hzs = [2, 8, 18, 32];
            damage += (damage * (hzs[hz - 1] / 100));
        } else if (src_unit["合纵"] && src_unit["合纵"] > 0) {
            damage += src_unit["合纵"];
        }
        if (src_unit["舍身击"]) {
            damage += src_unit["舍身击"]
        }
    }

    if (target_unit["物伤减少"]) {
        damage = damage * target_unit["物伤减少"];
    }
    if (src_unit["百步穿杨"] && G.RandomUtils.chance(20)) {
        damage += src_unit["百步穿杨"];
    }
    if (target_unit["暗渡陈仓"]) {
        damage = damage * target_unit["暗渡陈仓"];
    }

    if (src_unit["玄灵珠"] && src_unit["玄灵珠破军"]) {
        if (G.RandomUtils.chance(src_unit["玄灵珠破军"] * 10)) {
            damage = damage * (1 + src_unit["玄灵珠破军"] * 0.1);
        }
    }

    damage = Math.floor(damage + (src_unit["物理伤害结果"] || 0) + (src_unit["物伤结果"] || 0));

    // 召唤兽主人千钧一怒
    if (src_unit["认证码"]) {
        let targe_number = src_unit["主人编号"];
        let master_unit = G.FightUtils.get_fight_unit_by_number(fight_data, targe_number);
        if (src_unit["千钧一怒"] && master_unit && master_unit["气血"] > 0) {
            if (damage >= target_unit["最大气血"] * 0.1) {
                G.FightUnitUtils.add_fen_nu(master_unit, 10);
            }
        }
    }

    return [damage, type, tx];
}

/**
 * 取法术伤害结果
 * @param {*} fight_data 
 * @param {*} src_unit 
 * @param {*} target_unit 
 * @param {*} damage 
 * @param {*} bj 
 * @param {*} skill_name 
 * @param {*} type 
 * @returns 
 */
function get_ap_damage_result(fight_data, src_unit, target_unit, damage, bj, skill_name, type) {
    let skill_data = G.SkillData.default[skill_name];
    let tx = [];
    // 最终返回的流程类型
    if (bj) {
        type = 3.5;
        tx.push("法术暴击");
    }

    // 攻击单位法术状态对法术伤害结果的影响
    for (const key in src_unit["法术状态"]) {
        if (G.SkillData.default[key] && G.SkillData.default[key]["攻击法伤结果"]) {
            let res = G.SkillData.default[key]["攻击法伤结果"](fight_data, src_unit, target_unit, damage);
            if (res) {
                return res;
            }
        }
    }

    // 被攻击单位法术状态对法术伤害结果的影响
    for (const key in target_unit["法术状态"]) {
        if (G.SkillData.default[key] && G.SkillData.default[key]["被攻击法伤结果"]) {
            let res = G.SkillData.default[key]["被攻击法伤结果"](fight_data, src_unit, target_unit, damage);
            if (res) {
                return res;
            }
        }
    }

    // 攻击单位奇经八脉对法术伤害结果的影响
    if (src_unit["奇经八脉"] && src_unit["门派"] !== "无门派") {
        let sects_jing_mai_data = G.JingMaiData.default[src_unit["门派"]];
        //门派统一处理
        if (sects_jing_mai_data["攻击法伤结果"]) {
            sects_jing_mai_data["攻击法伤结果"](fight_data, src_unit, target_unit, damage);
        }
        // 已点经脉
        for (const key in src_unit["奇经八脉"]) {
            if (src_unit["奇经八脉"][key] === 1 && sects_jing_mai_data[key] && sects_jing_mai_data[key]["攻击法伤结果"]) {
                sects_jing_mai_data[key]["攻击法伤结果"](fight_data, src_unit, target_unit, damage);
            }
        }
    }

    // 被攻击单位奇经八脉对法术伤害结果的影响
    if (target_unit["奇经八脉"] && target_unit["门派"] !== "无门派") {
        let sects_jing_mai_data = G.JingMaiData.default[target_unit["门派"]];
        //门派统一处理
        if (sects_jing_mai_data["被攻击法伤结果"]) {
            sects_jing_mai_data["被攻击法伤结果"](fight_data, src_unit, target_unit, damage);
        }
        // 已点经脉
        for (const key in target_unit["奇经八脉"]) {
            if (target_unit["奇经八脉"][key] === 1 && sects_jing_mai_data[key] && sects_jing_mai_data[key]["被攻击法伤结果"]) {
                sects_jing_mai_data[key]["被攻击法伤结果"](fight_data, src_unit, target_unit, damage);
            }
        }
    }

    //  攻击单位内丹属性对法术伤害结果的影响
    for (const key in src_unit["内丹属性"]) {
        let nei_dan_data = G.NeiDanData.default[key]
        if (nei_dan_data && nei_dan_data["攻击法伤结果"]) {
            console.debug(`攻击法伤结果 ===> 内丹属性 ${key}`);
            nei_dan_data["攻击法伤结果"](fight_data, src_unit, target_unit, damage);
        }
    }

    //  被攻击单位内丹属性对法术伤害结果的影响
    for (const key in target_unit["内丹属性"]) {
        let nei_dan_data = G.NeiDanData.default[key]
        if (nei_dan_data && nei_dan_data["被攻击法伤结果"]) {
            console.debug(`被攻击法伤结果 ===> 内丹属性 ${key}`);
            nei_dan_data["被攻击法伤结果"](fight_data, src_unit, target_unit, damage);
        }
    }

    if (G.FightUnitUtils.check_unit_shen_qi_skill(src_unit, "流火")
        && (src_unit["气血"] / src_unit["最大气血"]) > (target_unit["气血"] / target_unit["最大气血"])) {
        damage = damage * (1 + 0.08 * src_unit["神器"]["佩戴"]["等级"]);
    }

    if (src_unit["玄灵珠"] && src_unit["玄灵珠"]["空灵"]) {
        damage = damage * (1 + src_unit["玄灵珠"]["空灵"] * 0.01);
    }

    // 其他伤害减免

    if (G.FightUnitUtils.check_unit_fa_bao(fight_data, target_unit, "降魔斗篷")) {
        damage = Math.floor(damage * 0.5);
        tx.push("金甲仙衣");
    } else if (G.FightUnitUtils.check_unit_fa_bao(fight_data, target_unit, "蟠龙玉璧")) {
        damage = damage * 0.8;
        if (!tx.includes("金甲仙衣")) {
            tx.push("金甲仙衣");
        }
    }

    //  法术减伤 -----------------      

    let remove_damage_ratio = 0;

    // 指定技能法术减伤
    if (skill_data && skill_data["法术减伤"]) {
        skill_data["法术减伤"](fight_data, src_unit, target_unit, remove_damage_ratio);
    }

    // 被攻击单位法术状态对法术减伤的影响
    for (const key in target_unit["法术状态"]) {
        if (G.SkillData.default[key] && G.SkillData.default[key]["被攻击减法伤"]) {
            G.SkillData.default[key]["被攻击减法伤"](fight_data, src_unit, target_unit, remove_damage_ratio);
        }
    }

    // 被攻击单位奇经八脉对法术减伤的影响
    if (target_unit["奇经八脉"] && target_unit["门派"] !== "无门派") {
        let sects_jing_mai_data = G.JingMaiData.default[target_unit["门派"]];
        // 已点经脉
        for (const key in target_unit["奇经八脉"]) {
            if (target_unit["奇经八脉"][key] === 1 && sects_jing_mai_data[key] && sects_jing_mai_data[key]["被攻击减法伤"]) {
                sects_jing_mai_data[key]["被攻击减法伤"](fight_data, src_unit, target_unit, remove_damage_ratio);
            }
        }
    }

    if (src_unit["内丹属性"]["通灵法"]) {
        remove_damage_ratio -= src_unit["内丹属性"]["通灵法"];
    }

    remove_damage_ratio += (target_unit["法术伤害减免"] || 0);

    if (remove_damage_ratio >= 0.65) {
        remove_damage_ratio = 0.65;
    }

    console.debug(`法术伤害减免系数 ${remove_damage_ratio}`);

    damage -= Math.floor(damage * remove_damage_ratio);

    // 减伤后触发
    if (remove_damage_ratio > 0) {
        if (skill_data && skill_data["减伤触发"]) {
            console.debug(`减伤触发 ${skill_name}`)
            damage = skill_data["减伤触发"](fight_data, src_unit, target_unit, damage);
        }
    }

    console.debug(`减伤后 ${damage}`);

    // TODO 符石技能
    if (target_unit["云随风舞"]) {
        damage -= target_unit["云随风舞"];
    }

    // TODO 符石技能
    if (target_unit["化敌为友"]) {
        damage = damage * target_unit["化敌为友"];
    }

    // 法系固定结果
    let final_damage = computing_ap_final_damage(fight_data, src_unit, target_unit, damage, skill_name);

    let ap_damage_result = src_unit["法术伤害结果"] || 0;

    damage = Math.floor(final_damage + ap_damage_result);

    return [damage, type, tx];
}

/**
 * 固定法伤
 * @param {*} fight_data 
 * @param {*} src_unit 
 * @param {*} target_unit 
 * @param {*} damage 
 * @param {*} skill_name 
 * @returns 
 */
function computing_ap_final_damage(fight_data, src_unit, target_unit, damage, skill_name) {
    console.debug(`固定法伤 :  src_unit： ${src_unit["编号"]}  target_unit：${target_unit["编号"]}  damage： ${damage} skill_name：${skill_name}`);

    let skill_data = G.SkillData.default[skill_name];
    if (skill_data && skill_data["追加固定法伤"]) {
        skill_data["追加固定法伤"](fight_data, src_unit, target_unit, damage)
    }

    // 攻击单位法术状态追加固定法伤
    for (const key in src_unit["法术状态"]) {
        if (G.SkillData.default[key] && G.SkillData.default[key]["追加固定法伤"]) {
            G.SkillData.default[key]["追加固定法伤"](fight_data, src_unit, target_unit, damage);
        }
    }

    // 攻击单位奇经八脉追加固定法伤
    if (src_unit["奇经八脉"] && src_unit["门派"] !== "无门派") {
        let sects_jing_mai_data = G.JingMaiData.default[src_unit["门派"]];
        // 已点经脉
        for (const key in src_unit["奇经八脉"]) {
            if (src_unit["奇经八脉"][key] === 1 && sects_jing_mai_data[key] && sects_jing_mai_data[key]["追加固定法伤"]) {
                sects_jing_mai_data[key]["追加固定法伤"](fight_data, src_unit, target_unit, damage);
            }
        }
    }

    if (src_unit["门派"] === "龙宫") {
        if (G.FightUnitUtils.check_unit_fa_bao(fight_data, src_unit, "镇海珠")) { //百分比增加
            let zz = 1 + G.FightUnitUtils.get_unit_fa_bao_jingjie(src_unit, "镇海珠") * 0.0067
            if (G.FightUnitUtils.check_fight_unit_jingmai(src_unit, "龙宫", "龙珠")) {
                zz = zz + 0.033;
            }
            damage = damage * zz;
        }
    } else if (src_unit["门派"] === "方寸山") {
        if (G.FightUnitUtils.check_unit_fa_bao(fight_data, src_unit, "救命毫毛")) {
            if (G.FightUnitUtils.check_fight_unit_jingmai(src_unit, "方寸山", "宝诀") || G.FightUnitUtils.check_fight_unit_jingmai(src_unit, "方寸山", "妙用")
                || G.FightUnitUtils.check_fight_unit_jingmai(src_unit, "方寸山", "不灭")) {
                damage = damage * (1 + G.FightUnitUtils.get_unit_fa_bao_jingjie(src_unit, "救命毫毛") / 2 / 100);
            }
        }
    } else if (src_unit["门派"] === "天宫") {
        if (G.FightUnitUtils.check_unit_fa_bao(fight_data, src_unit, "伏魔天书")) {
            if (G.FightUnitUtils.check_fight_unit_jingmai(src_unit, "天宫", "伏魔")) {
                damage += Math.floor(G.FightUnitUtils.get_unit_fa_bao_jingjie(src_unit, "伏魔天书") / 2 * G.RandomUtils.generate_random(20, 30) * 1.5);
            } else {
                damage += Math.floor(G.FightUnitUtils.get_unit_fa_bao_jingjie(src_unit, "伏魔天书") / 2 * G.RandomUtils.generate_random(20, 30));
            }
        }
    }

    console.debug(`固定法伤结果 : ${damage}`);
    return Math.floor(damage);
}

/**
 * 附加施法计算
 * @param {*} fight_data 
 * @param {*} src_unit 
 * @param {*} target_unit 
 * @param {*} damage 
 * @param {*} damage_type 
 * @param {*} skill_name 
 * @param {*} tx 
 */
export function computing_ext_process_data(fight_data, src_unit, target_unit, damage, damage_type, skill_name, tx) {
    if (fight_data["战斗流程"].length === 0) {
        fight_data["战斗流程"].push({});
    }
    // 最后一个流程下标
    let current_process_data_index = fight_data["战斗流程"].length - 1;
    if (fight_data["战斗流程"][current_process_data_index]["附加施法"] === undefined) {
        // 初始化最后一个流程的附加施法信息
        fight_data["战斗流程"][current_process_data_index]["附加施法"] = [];
        fight_data["战斗流程"][current_process_data_index]["附加施法"].push({ "攻击方": src_unit["编号"], "被攻击": [] });
    }
    // 附加施法信息
    let current_process_ext_data;
    if (fight_data["战斗流程"][current_process_data_index]["附加施法"]["攻击方"] === src_unit["编号"]) {
        // 最后一个附加施法是当前攻击单位的
        let current_process_ext_data_index = fight_data["战斗流程"][current_process_data_index]["附加施法"].length - 1;
        current_process_ext_data = fight_data["战斗流程"][current_process_data_index]["附加施法"][current_process_ext_data_index];
        // 加一个被攻击信息
        current_process_ext_data["被攻击"].push({ "编号": target_unit["编号"], "特效": tx });
    } else if (fight_data["战斗流程"][fight_data["战斗流程"].length]["附加施法"]["攻击方"] !== src_unit["编号"]) {
        // 加一个附加施法信息
        fight_data["战斗流程"][current_process_data_index]["附加施法"].push({ "攻击方": src_unit["编号"], "被攻击": [] });
        let current_process_ext_data_index = fight_data["战斗流程"][current_process_data_index]["附加施法"].length - 1;
        current_process_ext_data = fight_data["战斗流程"][current_process_data_index]["附加施法"][current_process_ext_data_index];
        current_process_ext_data["被攻击"].push({ "编号": target_unit["编号"], "特效": tx });
    }
    if (damage_type === 1 || damage_type === 2 || damage_type === 3 || damage_type === 3.5) {
        current_process_ext_data["被攻击"][current_process_ext_data["被攻击"].length - 1]["伤害"] = damage;
        current_process_ext_data["被攻击"][current_process_ext_data["被攻击"].length - 1]["类型"] = damage_type;
        if (damage_type === 2) {
            // 加血
            add_target_hp_and_play(target_unit, damage);
        } else {
            // 扣血
            let die = computing_remove_hp(fight_data, src_unit, target_unit, damage, skill_name);
            current_process_ext_data["被攻击"][current_process_ext_data["被攻击"].length - 1]["死亡"] = die;
        }
    }

}

/**
 * 捕捉计算
 * @param {*} fight_data 
 * @param {*} src_unit 
 * @param {*} target_unit 
 */
export function computing_capture_process_data(fight_data, src_unit, target_unit) {
    if (!G.FightUnitUtils.get_target_unit_status(src_unit, target_unit, 1)) {
        ClientUtils.send_characters_basic_prompt(src_unit["id"], "#Y/目标当前无法被捕获");
        return;
    }
    if (target_unit["类型"] === "角色" || target_unit["类型"] === "召唤") {
        ClientUtils.send_characters_basic_prompt(src_unit["id"], "#Y/无法捕捉的目标,非法操作");
        return;
    }

    if (target_unit["精灵"]) {
        ClientUtils.send_characters_basic_prompt(src_unit["id"], "#Y/你无法捕捉这样的目标");
        return;
    }

    if (src_unit["魔法"] < Math.floor(target_unit["等级"] * 0.5 + 20)) {
        ClientUtils.send_characters_basic_prompt(src_unit["id"], "#Y/没有足够的魔法");
        return;
    }
    let characters = _CharactersData.get(fight_data["id"]);
    if (characters["召唤兽"].length >= characters["召唤兽携带上限"]) {
        ClientUtils.send_characters_basic_prompt(src_unit["id"], "#Y/你无法携带更多的宝宝了");
        return;
    }

    //减少魔法 TODO 应当是消耗
    G.FightUnitUtils.remove_unit_mp(fight_data, src_unit, target_unit["等级"] * 0.5 + 20);

    //添加流程
    fight_data["战斗流程"].push({ "流程": 300, "攻击方": src_unit["编号"], "被攻击": [{ "编号": target_unit["编号"] }] });
    fight_data["战斗流程"][fight_data["战斗流程"].length - 1]["宝宝"] = src_unit["模型"];
    fight_data["战斗流程"][fight_data["战斗流程"].length - 1]["名称"] = src_unit["名称"];
    G.FightUtils.add_waiting_play_time(fight_data, 1, "捕捉");

    // 捕捉几率
    let gl = 45;
    // 捕捉几率加成
    gl += Math.floor(src_unit["最大气血"] / src_unit["气血"]) * 10 + Math.floor((src_unit["猎术修炼"] || 0) * 3);
    if (G.RandomUtils.chance(gl)) {
        fight_data["战斗流程"][fight_data["战斗流程"].length - 1]["捕捉成功"] = true;
        target_unit["气血"] = 0;
        target_unit["捕捉"] = true;
        target_unit["可捕捉"] = false;
        ClientUtils.send_characters_basic_prompt(src_unit["id"], `#Y/你成功捕捉了#R/${target_unit["名称"]}`);
        // 构建宠物数据
        G.Characters.add_pet(src_unit["id"], target_unit["名称"]);
    } else {
        ClientUtils.send_characters_basic_prompt(src_unit["id"], "#Y/捕捉失败");
    }
}

/**
 * 逃跑计算
 * @param {*} fight_data 
 * @param {*} src_unit 
 * @param {*} ext_gl 
 * @returns 
 */
export function computing_run_away(fight_data, src_unit, ext_gl = 0) {
    console.debug(`逃跑计算 => 编号: ${src_unit["编号"]} 类型: ${src_unit["类型"]}`)
    let run_away = false;
    let status_count = G.FightUnitUtils.get_unit_run_away_status(src_unit);
    let gl = 80 - status_count + ext_gl;
    // 怪物百分百逃跑
    if (src_unit["队伍"] === 0) {
        gl = 100;
    }
    if (src_unit["认证码"]) {
        let res = G.FightUtils.get_friend_nei_dan_count(fight_data, src_unit, "凛冽气");
        if (res[0] > 0) {
            gl -= res[1];
        }
    }

    if (src_unit["义薄云天"]) {
        gl = 0;
    }

    if (G.RandomUtils.chance(gl)) {
        run_away = true;
    }

    console.debug(`逃跑计算 => 结果: ${run_away}`)

    let say_text = G.RandomUtils.random_get_array(["溜了溜了！", "风紧扯呼"]);
    //逃跑流程
    fight_data["战斗流程"].push({ "流程": 601, "id": src_unit["id"], "成功": run_away, "喊话": say_text, "攻击方": src_unit["编号"], "被攻击": [{ "编号": 1 }] });
    G.FightUtils.add_waiting_play_time(fight_data, 5, "逃跑");
    if (run_away) {
        src_unit["逃跑"] = true;
        if (src_unit["认证码"]) {
            // 召唤兽逃跑
            let marster_number = src_unit["主人编号"];
            let marster_unit = G.FightUtils.get_fight_unit_by_number(fight_data, marster_number);
            let marster_characters = _CharactersData.get(marster_unit["id"]);
            // 通知客户端刷新参战宝宝信息
            ClientUtils.send_characters_client_message(marster_characters["id"], 18, {});
        }
        if (src_unit["类型"] === "角色" && src_unit["参战宝宝"]) {
            //召唤兽也逃跑
            let pet_unit = fight_data["队伍数据"][src_unit["下标"] + 1];
            pet_unit["逃跑"] = true;
            fight_data["战斗流程"][fight_data["战斗流程"].length - 1]["追加"] = pet_unit["编号"];
        }
    }
}

/**
 * 法宝流程计算
 * @param {*} fight_data 
 * @param {*} src_unit 
 * @param {*} target_unit 
 * @param {*} index 
 * @returns 
 */
export function computing_fabao_process(fight_data, src_unit, target_unit, index) {
    let fb = src_unit["法宝"][index];
    if (fb === undefined) {
        ClientUtils.send_characters_basic_prompt(src_unit["id"], "#Y/要使用法宝的不存在");
        return;
    }
    console.debug(`法宝流程计算开始 ======> 使用方: ${target_unit["编号"]} 目标: ${target_unit["编号"]} 名称: ${fb["名称"]}`)
    if (!G.FightUnitUtils.get_unit_ap_fabao_kill_status(src_unit) || G.FightUnitUtils.check_unit_rest_status(src_unit)) {
        ClientUtils.send_characters_basic_prompt(src_unit["id"], "#Y/当前状态无法使用法宝");
        return;
    }

    if (src_unit["等级"] < fb["等级限制"]) {
        ClientUtils.send_characters_basic_prompt(src_unit["id"], "#Y/您的等级不足以驾驭此法宝");
        return;
    }

    if (fb["灵气"] >= 5) {
        fb["灵气"] -= 5;
        ClientUtils.send_characters_basic_prompt(src_unit["id"], `#Y/你的法宝[#G/"${fb["名称"]}"#Y/]灵气减少了5点`);
    } else {
        ClientUtils.send_characters_basic_prompt(src_unit["id"], `#Y/你的法宝[#G/"${fb["名称"]}"#Y/]灵气不足无法使用`);
        return;
    }

    // 设置下一次可使用的回合
    if (fb["回合"] > fight_data["回合"]) {
        ClientUtils.send_characters_basic_prompt(src_unit["id"], `#Y/你的法宝[#G/"${fb["名称"]}"#Y/]在当前回合无法使用`);
        return;
    }

    fb["回合"] = fight_data["回合"] + fb["冷却回合"];

    // 法宝算法演算
    if (_FaBaoData.has(fb["名称"]) && _FaBaoData.get(fb["名称"])["法宝算法"]) {
        _FaBaoData.get(fb["名称"])["法宝算法"](fight_data, src_unit, target_unit, fb);
    }

    // 法宝回合影响
    if (_FaBaoData.has(fb["名称"]) && _FaBaoData.get(fb["名称"])["回合影响"]) {
        _FaBaoData.get(fb["名称"])["回合影响"](fight_data, src_unit, fb);
    }

    if (G.FightUnitUtils.check_fight_unit_jingmai(src_unit, "天宫", "神念")) {
        G.FightUnitUtils.add_fen_nu(src_unit, 10);
    }
    if (src_unit["法术状态"]["愈勇"]) {
        G.FightStatusUtils.canel_unit_status(fight_data, "愈勇", src_unit)
    }
    console.debug(`法宝流程计算结束 ======> 使用方: ${target_unit["编号"]} 目标: ${target_unit["编号"]} 名称: ${fb["名称"]}`)
}

/**
 * 治疗量计算
 * @param {*} src_unit 发起单位
 * @param {*} target_unit 目标单位
 * @param {*} skill_name 技能名称
 * @param {*} heals  治疗量
 * @returns 
 */
export function computing_heals(fight_data, src_unit, target_unit, skill_name, heals) {
	console.debug(`治疗量计算开始 ===> 编号: ${src_unit["编号"]} 类型: ${src_unit["类型"]} 气血: ${src_unit["气血"]} 目标编号: ${target_unit["编号"] ? target_unit["编号"] : "无"} 技能：${skill_name} heals ${skill_name}`);
	if (target_unit["法术状态"] && target_unit["法术状态"]["魔音摄魂"]) {
		return 0;
	}
	if (src_unit["法术状态"]["佛法无边"] && src_unit["法术状态"]["佛法无边"]["佛法"]) {
		heals = Math.floor(heals * 1.3);
	}
	if (target_unit["法术状态"] && target_unit["法术状态"]["含情脉脉"] && target_unit["法术状态"]["含情脉脉"]["忘情"]) {
		heals = Math.floor(heals * target_unit["法术状态"]["含情脉脉"]["忘情"]);
	}
	if (target_unit["法术状态"] && target_unit["法术状态"]["腾雷"]) {
		heals = Math.floor(heals * 0.5);
	}
	if (target_unit["净土灵华"]) {
		heals = Math.floor(heals * (1 - target_unit["净土灵华"]));
	}
	if (src_unit["法术状态"]["莲心剑意"]) {
		heals = Math.floor(heals * 0.9);
	}
	if (src_unit["门派"] === "化生寺") {
		if (G.FightUnitUtils.check_fight_unit_jingmai(src_unit, "化生寺", "施他") && src_unit["增益"] && src_unit["增益"] > 0) {
			heals = heals + 40;
		}
		if (G.FightUnitUtils.check_unit_shen_qi_skill(src_unit, "挥毫") && target_unit["增益"]) {
			heals = heals + 25 * src_unit["神器"]["等级"] * target_unit["增益"];
		}
	} else if (src_unit["门派"] === "无底洞") {
		if (G.FightUnitUtils.check_fight_unit_jingmai(src_unit, "无底洞", "秉幽")) {
			heals = heals + (src_unit["装备伤害"] * 0.18);
		} else if (G.FightUnitUtils.check_fight_unit_jingmai(src_unit, "无底洞", "灵照")) {
			heals = heals + (src_unit["装备伤害"] * 0.03 * G.FightUtils.get_all_number_buff_count(fight_data, "增益"));
		} else if (G.FightUnitUtils.check_fight_unit_jingmai(src_unit, "无底洞", "灵照")) {
			heals = heals + (src_unit["装备伤害"] * 0.04 * G.FightUtils.get_all_number_buff_count(fight_data, "护盾"));
		}
		if (G.FightUnitUtils.check_fight_unit_jingmai(src_unit, "无底洞", "涌泉") && target_unit["编号"] === src_unit["指令"]["目标"]) {
			heals = heals + G.FightUnitUtils.get_unit_skill_level(src_unit, "地冥妙法") * 6;
		}
	}
	// 法术修炼对治疗量的影响
	heals = heals + src_unit["法术修炼"] * 5;
	// 气血回复效果对治疗量的影响
	heals = heals + target_unit["气血回复效果"];
	// 治疗能力对治疗量的影响
	heals = heals + src_unit["治疗能力"]
	// 五行珠被动对治疗量的影响
	if (G.FightUnitUtils.check_fight_unit_passive_skill(target_unit, "五行珠")) {
		heals = Math.floor(heals * 0.5);
	}
	// 共生对治疗量的影响
	if (target_unit["共生"]) {
		heals = heals * 2;
	}
	// 镜花水月对治疗量的影响
	if (G.FightUnitUtils.check_unit_shen_qi_skill(src_unit, "镜花水月") && G.RandomUtils.chance(8 * src_unit["神器"]["等级"])) {
		G.FightUnitUtils.add_hu_dun_for_lt_hp(fight_data, target_unit, heals);
	}
	console.debug(`治疗量计算结束 ===> heals ${heals}`);
	return Math.floor(heals);
}